import java.util.*;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: AliceMana
 * Date: 2022-10-04
 * Time: 8:58
 */
class Time implements Comparable<Time> {
    public int hour;
    public int min;
    public int sec;

    @Override
    public int compareTo(Time o) {
        if (this.hour == o.hour) {
            if (this.min == o.min) {
                return this.sec-o.sec;
            }
            return this.min-o.min;
        }
        return this.hour-o.hour;
    }

    @Override
    public String toString() {
        return hour+" "+min+" "+sec;
    }
}
public class Main {
    // 链接：https://ac.nowcoder.com/acm/contest/42355/1014
    //来源：牛客网
    //
    //自从ZZZZone吃完糖果后，他开始改吃巧克力了，他每天想吃n个巧克力增在甜蜜值，他决定早上吃K个巧克力，晚上吃n - K个巧克力，
    // 每个巧克力在早上吃和在晚上吃的甜蜜值是不一样的，他想让自己得到的甜蜜值最大，并想知道最大是多少。
    //请你编程帮助他。
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k = in.nextInt();
        long res = 0;

        int[] arr = new int[n];
        int[] mo = new int[n];
        int[] ni = new int[n];
        for (int i = 0; i < n; i++) {
            mo[i] = in.nextInt();
        }
        for (int i = 0; i < n; i++) {
            ni[i] = in.nextInt();
            res += ni[i];
            arr[i] = mo[i] - ni[i];
        }
        Arrays.sort(arr);
        for (int i = n-1; i >= n-k; i--) {
            res += arr[i];
        }
        System.out.println(res);
    }

    //有n个队伍，每个队伍的人数小于等于5，每辆车最多坐5个人，要求一个队伍的人都在一辆车上，求最少的车数
    public static void main24(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = in.nextInt();
        }
        int res = 0;
        int[] count = new int[6];
        for (int i = 0; i < n; i++) {
            count[arr[i]]++;
        }
        res += count[5];
        int allTeam = count[1]+count[2]+count[3]+count[4];
        while (allTeam != 0) {
            int c = 0;
            for (int i = 4; i >= 1; i--) {
                while (count[i] != 0 && c + i <= 5) {
                    allTeam--;
                    count[i]--;
                    c += i;
                }
            }
            res++;
        }
        System.out.println(res);
    }

    //小H陷入了一个迷宫中，迷宫里有一个可怕的怪兽，血量有N点，小H有三瓶魔法药水，
    // 分别可以使怪兽损失a%、b%、c%的血量(之后怪兽的血量会向下取整)，小H想合理地运用这三瓶药水，
    // 使怪兽失去尽可能多的血量
    //  注意:每瓶药水只能用一次
    public static void main23(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] arr = new int[3];
        for (int i = 0; i < 3; i++) {
            arr[i] = in.nextInt();
        }
        Arrays.sort(arr);
        int ret = n;
        for (int i = 2; i >= 0; i--) {
            ret *= 1 - arr[i]/100.0;
        }
        System.out.println(n-ret);
    }

    //每一本正式出版的图书都有一个ISBN号码与之对应，ISBN码包括9位数字、1位识别码和3位分隔符，其规定格式如“x-xxx-xxxxx-x”，其中符号“-”是分隔符（键盘上的减号），最后一位是识别码，例如0-670-82162-4就是一个标准的ISBN码。ISBN码的首位数字表示书籍的出版语言，例如0代表英语；第一个分隔符“-”之后的三位数字代表出版社，例如670代表维京出版社；第二个分隔之后的五位数字代表该书在出版社的编号；最后一位为识别码。
    //识别码的计算方法如下：
    //首位数字乘以1加上次位数字乘以2……以此类推，用所得的结果mod 11，所得的余数即为识别码，如果余数为10，则识别码为大写字母X。例如ISBN号码0-670-82162-4中的识别码4是这样得到的：对067082162这9个数字，从左至右，分别乘以1，2，…，9，再求和，即0×1+6×2+……+2×9=158，然后取158 mod 11的结果4作为识别码。
    //你的任务是编写程序判断输入的ISBN号码中识别码是否正确，如果正确，则仅输出“Right”；如果错误，则输出你认为是正确的ISBN号码。
    public static void main22(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        int sum = 0;
        int j = 1;
        for (int i = 0; i < 11; i++) {
            if (Character.isDigit(str.charAt(i))) {
                sum += (str.charAt(i)-'0') * j;
                j++;
            }
        }
        if ((int)str.charAt(12)-'0' == sum%11||((int)str.charAt(12) == 'X' && sum%11==10)) {
            System.out.println("Right");
        } else {
            if (sum%11 == 10) {
                System.out.println(str.substring(0, 12)+'X');
            } else {
                System.out.println(str.substring(0, 12)+(sum%11));
            }
        }
    }


    //扫雷游戏是一款十分经典的单机小游戏。在n行m列的雷区中有一些格子含有地雷（称之为地雷格），
    //其他格子不含地雷（称之为非地雷格）。
    //玩家翻开一个非地雷格时，该格将会出现一个数字——提示周围格子中有多少个是地雷格。
    //现在给出n行m列的雷区中的地雷分布，请计算出每个非地雷格周围的地雷格数。
    //
    //注：一个格子的周围格子包括其上、下、左、右、左上、右上、左下、右下八个方向上与之直接相邻的格子。
    public static void main21(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        String[] str = new String[n];
        in.nextLine();
        for (int i = 0; i < n; i++) {
            str[i] = " "+in.nextLine()+" ";
        }
        char[][] arr = new char[n+2][m+2];
        for (int i = 0; i < n; i++) {
            arr[i+1] = str[i].toCharArray();
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                int count = 0;
                if (arr[i][j] == '?') {
                    if (arr[i-1][j-1] == '*') {
                        count++;
                    }
                    if (arr[i-1][j] == '*') {
                        count++;
                    }
                    if (arr[i-1][j+1] == '*') {
                        count++;
                    }
                    if (arr[i][j-1] == '*') {
                        count++;
                    }
                    if (arr[i][j+1] == '*') {
                        count++;
                    }
                    if (arr[i+1][j-1] == '*') {
                        count++;
                    }
                    if (arr[i+1][j] == '*') {
                        count++;
                    }
                    if (arr[i+1][j+1] == '*') {
                        count++;
                    }
                    arr[i][j] = (char)count;
                }
            }
        }

        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (arr[i][j] == '*'){
                    System.out.print('*');
                } else {
                    System.out.print((int) arr[i][j]);
                }
            }
            System.out.println();
        }
    }

    //你有一个长度为 n 序列 {a}(序列下标从1开始) ，每次可以从任意位置 i 花费 ai*i 的代价来把 ai 删除。
    //注意，删除后 ai 后面的数会依次向前补上（下标 -1 ) 。
    //求把整个序列删完的最小代价。
    public static void main20(String[] args) {
        Scanner in = new Scanner(System.in);
        long n = in.nextLong();
        List<Long> list = new ArrayList<>();
        long ret = 0;
        for (int i = 0; i < n; i++) {
            long k = in.nextLong();
            list.add(k);
        }
        int sz = list.size();
        for (int i = sz-1; i >= 0; i--) {
            if (list.get(i) < 0) {
                ret += list.get(i)*(i + 1);
            }
        }
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i) > 0) {
                ret += list.get(i);
            }
        }
        System.out.println(ret);
    }
    //在中国象棋中正所谓新手玩车，熟手玩炮，老手玩马，由此可见象棋中炮的地位还是比较高的。
    //
    //给定一个n \times mn×m的棋盘，全部摆满炮，我们视所有炮都不属于同一阵营，
    // 他们之间可以相互攻击但不能不进行攻击直接移动。请问经历若干次攻击，直到不能攻击后，最少能剩余多少个炮。
    public static void main19(String[] args) {
        Scanner in = new Scanner(System.in);
        int frequency = in.nextInt();
        while (frequency != 0) {
            frequency--;
            long m = in.nextLong();
            long n = in.nextLong();
            if (m == 0 && n == 0) {
                System.out.println(0);
                continue;
            }
            if (m == 1 && n == 1) {
                System.out.println(1);
                continue;
            }
            if (m == 1 || n == 1) {
                System.out.println(2);
                continue;
            }
            System.out.println(4);
        }
    }


    public static void main18(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int x = in.nextInt();
        int count = 0;
        while (n > x) {
            if (n/5 >= x && n-x <= x) {
                n -= x;
                count++;
                break;
            }
            n /= 2;
            count++;
        }
        if (n > 0) {
            count++;
        }
        System.out.println(count);
    }
    public static void main17(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        List<Integer> teams = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            int team = in.nextInt();
            teams.add(team);
        }
        Collections.sort(teams);
        int carCount = 0;
        /*
         * 把五人队全都分一辆车
         */
        for (int i = teams.size()-1; i >= 0 ; i--) {
            if (teams.get(i) == 5) {
                carCount++;
                teams.remove(i);
            } else {
                break;
            }
            if (teams.isEmpty()) {
                break;
            }
        }
        /*
         * 把四人队跟一人队凑一辆车
         */
        while (teams.get(0)==1 && teams.get(teams.size()-1) == 4) {
                teams.remove(0);
                teams.remove(teams.size()-1);
                carCount++;
            if (teams.isEmpty()) {
                break;
            }
        }
        /*
         * 判断四人队有剩余的情况
         */
        while (teams.get(teams.size()-1) == 4) {
            teams.remove(teams.size()-1);
            carCount++;
        }
        /*
        组合三人队和两人队 或 三人队和两个一人队组合
         */
        while (teams.get(teams.size()-1)==3 && teams.get(0)==1 && teams.get(1)==1) {
            teams.remove(0);
            teams.remove(0);
            teams.remove(teams.size()-1);
            carCount++;
            if (teams.isEmpty()) {
                break;
            }
        }
        while (teams.get(teams.size()-1)==3 && (teams.get(0)==1 || teams.get(0)==2)) {
            if (teams.get(0) == 2) {
                teams.remove(0);
            } else {
                teams.remove(1);
            }
            teams.remove(teams.size()-1);
            carCount++;
            if (teams.isEmpty()) {
                break;
            }
        }
        /*
        考虑2 2 1的情况
         */
        while (teams.get(0)==1 && teams.get(teams.size()-1)==2 && teams.get(teams.size()-2)==2) {
            teams.remove(0);
            teams.remove(teams.size()-1);
            teams.remove(teams.size()-1);
            carCount++;
            if (teams.isEmpty()) {
                break;
            }
        }
        /*
        如果2人队前有三个一人队
         */
        while (teams.get(teams.size()-1)==2 && teams.get(0)==1 && teams.get(1)==1 && teams.get(2)==1) {
            teams.remove(0);
            teams.remove(0);
            teams.remove(0);
            teams.remove(teams.size()-1);
            carCount++;
            if (teams.isEmpty()) {
                break;
            }
        }

        int peopleCount = 0;
        for (int i = 0; i < teams.size(); i++) {
            peopleCount += teams.get(i);
            if (peopleCount == 5) {
                carCount++;
                peopleCount = 0;
            }
            if (peopleCount > 5) {
                carCount++;
                peopleCount = teams.get(i);
            }
        }
        if (peopleCount != 0) {
            carCount++;
        }
        System.out.println(carCount);
    }

    public static void main16(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        List<Time> times = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            Time time = new Time();
            time.hour = in.nextInt();
            time.min = in.nextInt();
            time.sec = in.nextInt();
            times.add(time);
        }
        Collections.sort(times);
        for (Time t:
             times) {
            System.out.println(t.toString());
        }
    }

    public static int fib2(int n) {
        if (n == 1) {
            return 0;
        }
        if (n == 2 || n == 3) {
            return 1;
        }
        return fib2(n-3)+2*fib2(n-2)+fib2(n-1);
    }
    public static void main14(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        System.out.println(fib2(n));
    }

    //给定一个整数，请将该数各个位上数字反转得到一个新数。
    // 新数也应满足整数的常见形式，即除非给定的原数为零，否则反转后得到的新数的最高位数字不应为零（参见样例2）。
    public static String revers(String str) {
        return new StringBuilder(str).reverse().toString();
    }
    public static void main13(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int flg = 1;
        if (n<0) {
            flg = -1;
            n = -n;
        }
        String str = String.valueOf(n);
        str = revers(str);
        n = Integer.parseInt(str);
        System.out.println(n*flg);
    }

    //给你n个数，有一个数的出现次数超过一半，请找出这个数。
    public static void main12(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = in.nextInt();
        }
        Arrays.sort(arr);
        System.out.println(arr[n/2]);
    }

    public static void main10(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        int letters = 0;
        int digits = 0;
        int others = 0;
        int i = 0;
        while (str.charAt(i) != '?') {
            if (Character.isLetter(str.charAt(i))) {
                letters++;
            } else if (Character.isDigit(str.charAt(i))) {
                digits++;
            } else {
                others++;
            }
            i++;
        }
        System.out.println("Letters="+letters);
        System.out.println("Digits="+digits);
        System.out.println("Others="+others);
    }

    // 帮助牛牛计算 1+（1+2）+（1+2+3）+...+(1+2+3+...+n)
    public static void main9(String[] args) {
        Scanner in = new Scanner(System.in);
        int ret = 0;
        int n = in.nextInt();
        for (int i = 1; i <= n; i++) {
            int sum = 0;
            for (int j = 1; j <= i; j++) {
                sum += j;
            }
            ret +=sum;
        }
        System.out.println(ret);
    }


    public static long fib(int n) {
        if (n == 1 || n == 2) {
            return 1;
        }
        return fib(n-2)+fib(n-1);
    }

    public static void main8(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        System.out.println(fib(n));
    }
    // 链接：https://ac.nowcoder.com/acm/contest/42355/1014
    //来源：牛客网
    //
    //自从ZZZZone吃完糖果后，他开始改吃巧克力了，他每天想吃n个巧克力增在甜蜜值，他决定早上吃K个巧克力，晚上吃n - K个巧克力，每个巧克力在早上吃和在晚上吃的甜蜜值是不一样的，他想让自己得到的甜蜜值最大，并想知道最大是多少。
    //请你编程帮助他。
    // 实际上是一个贪心思想，先全部按照晚上的甜度吃，然后求得早上的甜度和晚上的甜度的差值（分正负），
    // 然后将差值从大到小排序，每次都加上早上的甜度比晚上甜度多出来的值。
    public static void main11(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int eatInMorning = in.nextInt();
        int eatInNight = n - eatInMorning;
        int[] morningValue = new int[n];
        int[] nightValue = new int[n];
        int sweetnessValue = 0;
        for (int i = 0; i < n; i++) {
            morningValue[i] = in.nextInt();
        }
        for (int i = 0; i < n; i++) {
            nightValue[i] = in.nextInt();
        }
        for (int i = 0; i < eatInMorning; i++) {
            sweetnessValue += morningValue[i];
        }
        for (int i = eatInMorning; i < n; i++) {
            sweetnessValue += nightValue[i];
        }
        System.out.println(sweetnessValue);
    }

    //请统计某个给定范围[L, R]的所有整数中，数字2出现的次数。
    //比如给定范围[2, 22]，数字2在数2中出现了1次，在数12中出现1次，在数20中出现1次，在数21中出现1次，
    // 在数22中出现2次，所以数字2在该范围内一共出现了6次。
    public static void main7(String[] args) {
        Scanner in = new Scanner(System.in);
        int l = in.nextInt();
        int r = in.nextInt();
        int count = 0;
        for (int i = l; i <= r; i++) {
            int n = i;
            while (n != 0) {
                int re = n%10;
                if (re == 2) {
                    count++;
                }
                n /= 10;
            }
        }
        System.out.println(count);
    }
    //牛牛准备继续进阶，计算更难的数列
    //输入一个整数n,计算 1+1/（1-3）+1/（1-3+5）+...+1/(1-3+5-...((-1)^(n-1))*(2n-1))的值
    public static int count(int n) {
        int ret1 = 0;
        int ret2 = 0;
        for (int i = 1; i <= 2*n-1; i+=4) {
            ret1 += i;
        }
        for (int i = 3; i <= 2*n-1; i+=4) {
            ret2 += i;
        }
        return ret1-ret2;
    }


    public static void main15(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        double ret = 0.0;
        for (int i = 1; i <= n; i++) {
            ret += 1.0/count(i);
        }
        System.out.printf("%.3f", ret);
    }

    // 这次牛牛又换了个数列，他想计算：1+1/2+1/3+…+1/N的值。(保留6位小数)
    public static void main6(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        double ret = 0.0;
        for (int i = 1; i <= n; i++) {
            ret += 1.0/i;
        }
        System.out.printf("%.6f", ret);
    }



    //牛牛开始学习数列啦
    //现在他想知道1-2+3-4...+n的值
    public static void main5(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int ret1 = 0;
        int ret2 = 0;
        for (int i = 1; i <= n; i+=2) {
            ret1 += i;
        }
        for (int i = 2; i <= n; i+=2) {
            ret2+=i;
        }
        System.out.println(ret1-ret2);
    }

    // 给你一个整数n，按要求输出n∗n的回型矩阵
    public static void main4(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int [][] arr = new int[n][n];
        int x = 0;
        int y = n-1;
        int count = 0;
        while (count < n*n) {
            for (int i = x; i <= y; i++) {
                arr[x][i] = ++count;
            }
            for (int i = x+1; i <= y; i++) {
                arr[i][y] = ++count;
            }
            for (int i = y-1; i >= x; i--) {
                arr[y][i] = ++count;
            }
            for (int i = y-1; i >= x+1; i--) {
                arr[i][x] = ++count;
            }
            x++;
            y--;
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
    }
    public static void main3(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = n%10;
        if (m > 4) {
            n = n+(10-m);
        } else {
            n = n - m;
        }
        System.out.println(n);
    }

    // 给你同一天里的两个时间(24小时制),求这两个时间内有多少分钟,保证第一个时间在第二个时间之前
    public static void main2(String[] args) {
        Scanner in = new Scanner(System.in);
        int h1 = in.nextInt();
        int m1 = in.nextInt();
        int h2 = in.nextInt();
        int m2 = in.nextInt();
        int ret = 0;
        if (h2 > h1) {
            ret = (h2 - h1)*60;
        }
        ret += m2-m1;
        System.out.println(ret);
    }

    public static void main1(String[] args) {
        System.out.println("hello nowcoder");
    }


}
